package solutions.ferpa.ztest.intf;

import br.com.telescope.adsrt.dom.DomId;
import br.com.telescope.adsrt.dom.DomOpcao;
import br.com.telescope.adsrt.dom.DomSourceCode;
import br.com.telescope.adsrt.dom.DomText;
import br.com.telescope.adsrt.dom.DomTextLong;
import br.com.telescope.adsrt.dom.DomUpper;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.ServiceModel;
import br.com.telescope.t2.exception.ApplicationRuntimeException;
import br.com.telescope.t2.feature.CustomFeature;
import br.com.telescope.t2.feature.DeleteFeature;
import br.com.telescope.t2.feature.InsertFeature;
import br.com.telescope.t2.feature.ListFeature;
import br.com.telescope.t2.feature.MethodFeature;
import br.com.telescope.t2.feature.QueryFeature;
import br.com.telescope.t2.feature.UpdateFeature;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import solutions.ferpa.ztest.ent.*;

/**
 * Cadastro de operações do sistema.
 * <p>
 * Interface de acesso ao cadastro de operações do sistema. Além do 
 * cadastramento tradicional, permite também a importação de dados.
 * <P>
 * Telescope origin: RTSYSINF.CAD_OPERACOES_SISTEMAS
 * <P>
 * Base entity: RTSYSINF.OPERACOES_SISTEMAS
 * <P>
 * @author TELESCOPE - Build task T2 Web Interface Generator
 * <P>
 * @version 0.1
 */
public class CadOperacoesSistemas extends ServiceModel {
    
    // <editor-fold defaultstate="collapsed" desc="Generated Code">
    public static final String GLOBAL_NAME = "RTSYSINF.CAD_OPERACOES_SISTEMAS";
    
    @Override
    public String globalName() {
        return GLOBAL_NAME;
    }
    
    {
        setTitle("Cadastro de operações do sistema");
    }
    
    protected EntOperacoesSistemas base;
    protected EntOperacoesSistemas rec; // NEED_TJW1_COMPATIBILITY
    
    // Record items
    private DomUpper aOperacao;
    private DomText aTitulo;
    private DomTextLong aDescricao;
    private DomOpcao aPoliticaAcesso;
    private DomSourceCode aImplementacao;
    private DomOpcao aTipo;
    private DomOpcao aSituacao;
    private DomId aInterfaceId;
    private DomId aTipoImplementacaoId;
    private DomId aId;
    private DomTextLong aImportText;
    
    // Query items
    private DomTextLong qDescricao;
    private DomOpcao qTipo;
    private DomText qTitulo;
    private DomUpper qOperacao;
    private DomOpcao qSituacao;
    private DomOpcao qPoliticaAcesso;
    
    @Override
    public String getBaseSql() {
        return "select BASE.*"
                + " from OPERACOES_SISTEMAS BASE";
    }
    
    @Override
    public void initAttributes() {
        
        aOperacao = new DomUpper();
        aOperacao.context(ctx).name("OPERACAO").label("Operação");
        
        aTitulo = new DomText();
        aTitulo.context(ctx).name("TITULO").label("Título");
        
        aDescricao = new DomTextLong();
        aDescricao.context(ctx).name("DESCRICAO").label("Descrição");
        
        aPoliticaAcesso = new DomOpcao();
        aPoliticaAcesso.context(ctx).name("POLITICA_ACESSO").label("Política de acesso").group(true);
        aPoliticaAcesso.addOption("P", "Público");
        aPoliticaAcesso.addOption("R", "Restrito");
        aPoliticaAcesso.addOption("U", "Usuário");
        aPoliticaAcesso.setDefaultValue("R");
        
        aImplementacao = new DomSourceCode();
        aImplementacao.context(ctx).name("IMPLEMENTACAO").label("Implementação");
        
        aTipo = new DomOpcao();
        aTipo.context(ctx).name("TIPO").label("Tipo").group(true);
        aTipo.addOption("I", "Implementação custom");
        aTipo.addOption("R", "Report");
        aTipo.addOption("S", "Service");
        aTipo.addOption("U", "User interface");
        aTipo.setDefaultValue("U");
        
        aSituacao = new DomOpcao();
        aSituacao.context(ctx).name("SITUACAO").label("Situação").group(true);
        aSituacao.addOption("A", "Ativo");
        aSituacao.addOption("I", "Inativo");
        aSituacao.setDefaultValue("A");
        
        aInterfaceId = new DomId();
        aInterfaceId.context(ctx).name("INTERFACE_ID").label("Interface do sistema");
        
        aTipoImplementacaoId = new DomId();
        aTipoImplementacaoId.context(ctx).name("TIPO_IMPLEMENTACAO_ID").label("Tipo de implementação");
        
        aId = new DomId();
        aId.context(ctx).name("ID").label("Id");
        
        aImportText = new DomTextLong();
        aImportText.context(ctx).name("IMPORT_TEXT").label("Texto a importar").unbound(true);
        
        
        qDescricao = new DomTextLong();
        qDescricao.context(ctx).name("DESCRICAO").label("Descrição");
        
        qTipo = new DomOpcao();
        qTipo.context(ctx).name("TIPO").label("Tipo");
        qTipo.addOption("I", "Implementação custom");
        qTipo.addOption("R", "Report");
        qTipo.addOption("S", "Service");
        qTipo.addOption("U", "User interface");
        
        qTitulo = new DomText();
        qTitulo.context(ctx).name("TITULO").label("Título");
        
        qOperacao = new DomUpper();
        qOperacao.context(ctx).name("OPERACAO").label("Operação");
        
        qSituacao = new DomOpcao();
        qSituacao.context(ctx).name("SITUACAO").label("Situação");
        qSituacao.addOption("A", "Ativo");
        qSituacao.addOption("I", "Inativo");
        
        qPoliticaAcesso = new DomOpcao();
        qPoliticaAcesso.context(ctx).name("POLITICA_ACESSO").label("Política de acesso");
        qPoliticaAcesso.addOption("P", "Público");
        qPoliticaAcesso.addOption("R", "Restrito");
        qPoliticaAcesso.addOption("U", "Usuário");
    }
    
    @Override
    public String getQueryPkColumn() {
        return "BASE.ID";
    }
    
    @Override
    public void setId(String value) {
        this.aId.setValue(value);
    }
    
    @Override
    public EntOperacoesSistemas getRecord() {
        if (base == null) {
            base = new EntOperacoesSistemas(ctx);
            rec = base;
        }
        return this.base;
    }
    
    @Override
    public String getContextName() {
        return aOperacao.toText();
    }
    
    @Override
    public String getDefaultOrderBy() {
        return "OPERACAO, TITULO, DESCRICAO, POLITICA_ACESSO";
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="QUERY">
    public class FQuery extends QueryFeature {
        
        @Override
        public void initForm() {
            addField(qOperacao, "opt");
            addField(qTitulo, "opt");
            addField(qDescricao, "opt");
            addField(qPoliticaAcesso, "opt");
            addField(qTipo, "opt");
            addField(qSituacao, "opt");
        }
        
        @Override
        public void onAction() {
            addSubmit(getFeature("IMPORT")).label("Importar").icon("importar.gif");
        }
        
        {
            setFeatureName("QUERY");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="LIST">
    public class FList extends ListFeature {
        
        @Override
        public void initForm() {
            addField(aOperacao, "view");
            addField(aTitulo, "view");
            addField(aDescricao, "view");
            addField(aPoliticaAcesso, "view");
            addField(aTipo, "view");
            addField(aSituacao, "view");
        }
        
        {
            setFeatureName("LIST");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="INSERT">
    public class FInsert extends InsertFeature {
        
        @Override
        public void initForm() {
            aOperacao.setOptional(false);
            addField(aOperacao, "rqd");
            addField(aTitulo, "opt");
            addField(aDescricao, "opt");
            aPoliticaAcesso.setOptional(false);
            addField(aPoliticaAcesso, "rqd");
            addField(aImplementacao, "opt");
            addField(aTipo, "opt");
            addField(aSituacao, "opt");
        }
        
        {
            setFeatureName("INSERT");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="UPDATE">
    public class FUpdate extends UpdateFeature {
        
        @Override
        public void initForm() {
            aOperacao.setOptional(false);
            addField(aOperacao, "rqd");
            addField(aTitulo, "opt");
            addField(aDescricao, "opt");
            aPoliticaAcesso.setOptional(false);
            addField(aPoliticaAcesso, "rqd");
            addField(aImplementacao, "opt");
            addField(aTipo, "opt");
            addField(aSituacao, "opt");
        }
        
        {
            setFeatureName("UPDATE");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="IMPORT">
    public class FImport extends CustomFeature {
        
        @Override
        public void initForm() {
            aImportText.setOptional(false);
            addField(aImportText, "rqd");
        }
        
        @Override
        public void onAction() {
            addCancel(getFeature("IMPORTAR_OPERACOES")).label("Importar operações").icon("importar.gif");
        }
        
        {
            setFeatureName("IMPORT");
            setTitle("Importar");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="DELETE">
    public class FDelete extends DeleteFeature {
        
        @Override
        public void initForm() {
            addField(aOperacao, "view");
        }
        
        {
            setFeatureName("DELETE");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="IMPORTAR_OPERACOES">
    public class FImportarOperacoes extends MethodFeature {
        
        @Override
        public void run() {
            preRun();
            try {
                importarOperacoes();
            } catch (AdsException ex) {
                throw new ApplicationRuntimeException(ex);
            }
        }
        
        {
            setFeatureName("IMPORTAR_OPERACOES");
            setTitle("Importar operações");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="initFeatures">
    
    @Override
    protected void initFeatures() {
        addFeature(new FQuery());
        addFeature(new FList());
        addFeature(new FInsert());
        addFeature(new FUpdate());
        addFeature(new FImport());
        addFeature(new FDelete());
        addFeature(new FImportarOperacoes());
        super.initFeatures();
    }
    
    @Override
    public String getDefaultFeature() {
        return "QUERY";
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Getters and Setters">
    
    public String getOperacao() {
        return aOperacao.getValue();
    }
    
    public void setOperacao(String value) {
        this.aOperacao.setValue(value);
    }
    
    public String getTitulo() {
        return aTitulo.getValue();
    }
    
    public void setTitulo(String value) {
        this.aTitulo.setValue(value);
    }
    
    public String getDescricao() {
        return aDescricao.getValue();
    }
    
    public void setDescricao(String value) {
        this.aDescricao.setValue(value);
    }
    
    public String getPoliticaAcesso() {
        return aPoliticaAcesso.getValue();
    }
    
    public void setPoliticaAcesso(String value) {
        this.aPoliticaAcesso.setValue(value);
    }
    
    public String getImplementacao() {
        return aImplementacao.getValue();
    }
    
    public void setImplementacao(String value) {
        this.aImplementacao.setValue(value);
    }
    
    public String getTipo() {
        return aTipo.getValue();
    }
    
    public void setTipo(String value) {
        this.aTipo.setValue(value);
    }
    
    public String getSituacao() {
        return aSituacao.getValue();
    }
    
    public void setSituacao(String value) {
        this.aSituacao.setValue(value);
    }
    
    public Long getInterfaceId() {
        return aInterfaceId.getValue();
    }
    
    public void setInterfaceId(Long value) {
        this.aInterfaceId.setValue(value);
    }
    
    public Long getTipoImplementacaoId() {
        return aTipoImplementacaoId.getValue();
    }
    
    public void setTipoImplementacaoId(Long value) {
        this.aTipoImplementacaoId.setValue(value);
    }
    
    @Override
    public Long getId() {
        return aId.getValue();
    }
    
    public void setId(Long value) {
        this.aId.setValue(value);
    }
    
    public String getImportText() {
        return aImportText.getValue();
    }
    
    public void setImportText(String value) {
        this.aImportText.setValue(value);
    }
    public String getQueryOperacao() {
        return qOperacao.getQueryValue();
    }
    
    public void setQueryOperacao(String value) {
        this.qOperacao.setQueryValue(value);
    }
    public String getQueryTitulo() {
        return qTitulo.getQueryValue();
    }
    
    public void setQueryTitulo(String value) {
        this.qTitulo.setQueryValue(value);
    }
    public String getQueryDescricao() {
        return qDescricao.getQueryValue();
    }
    
    public void setQueryDescricao(String value) {
        this.qDescricao.setQueryValue(value);
    }
    public String getQueryPoliticaAcesso() {
        return qPoliticaAcesso.getQueryValue();
    }
    
    public void setQueryPoliticaAcesso(String value) {
        this.qPoliticaAcesso.setQueryValue(value);
    }
    public String getQueryTipo() {
        return qTipo.getQueryValue();
    }
    
    public void setQueryTipo(String value) {
        this.qTipo.setQueryValue(value);
    }
    public String getQuerySituacao() {
        return qSituacao.getQueryValue();
    }
    
    public void setQuerySituacao(String value) {
        this.qSituacao.setQueryValue(value);
    }
    // </editor-fold>
    
    /**
     * Importar operações.
     * <p>
     * Lê o texto de importação informado e importa os respectivos 
     * registros.
     * <P>
     */
    private void importarOperacoes() throws AdsException {
        // <user-code id="752946" parentId="752492" hashcode="-26de5e61" length="1112">
        // import java.net.URLDecoder;
        // import java.io.UnsupportedEncodingException;
        
        aImportText.getHtmlParameter(ads);
        ads.p("Resultado da importação:");
        EntOperacoesSistemas op = new EntOperacoesSistemas(ads);
        
        String[] linha = aImportText.toString().split("\n");
        for (int i=0; i<linha.length; i++) {
            String[] coluna = linha[i].split(";");
            if (coluna.length == 3) {
                try {
                    op.nullifyId();
                    op.setOperacao(URLDecoder.decode(coluna[0],"UTF-8"));
                    op.setTitulo(URLDecoder.decode(coluna[1],"UTF-8"));
                    op.setDescricao(URLDecoder.decode(coluna[2],"UTF-8"));
                    ads.p("Operação: " + op.getOperacao() + "<br>");
                    ads.p("Titulo: " + op.getTitulo() + "<br>");
                    ads.p("Descrição: " + op.getDescricao() + "<br>");
                    op.ins();
                    ads.p("<b>OK!</b>");
                } catch (UnsupportedEncodingException ex) {
                    ads.p("Erro ao interpretar: <pre>");
                    ads.p(aImportText.toString() + "</pre");
                    ads.p("<b>ERRO!</b>");
                }
            }
        }
        
        getFeature("IMPORT").run();
        
        // </user-code>
    }
}
